/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include <dlfcn.h>
#include <pthread.h>
#include <stdio.h>
#include "linker.h"
#include "linker_format.h"

#include "irt_syscalls.h"

#define DL_SUCCESS                    0
#define DL_ERR_CANNOT_LOAD_LIBRARY    1
#define DL_ERR_INVALID_LIBRARY_HANDLE 2
#define DL_ERR_BAD_SYMBOL_NAME        3
#define DL_ERR_SYMBOL_NOT_FOUND       4
#define DL_ERR_SYMBOL_NOT_GLOBAL      5

static char dl_err_buf[1024];
static const char *dl_err_str;

static const char *dl_errors[] = {
    [DL_ERR_CANNOT_LOAD_LIBRARY] = "Cannot load library",
    [DL_ERR_INVALID_LIBRARY_HANDLE] = "Invalid library handle",
    [DL_ERR_BAD_SYMBOL_NAME] = "Invalid symbol name",
    [DL_ERR_SYMBOL_NOT_FOUND] = "Symbol not found",
    [DL_ERR_SYMBOL_NOT_GLOBAL] = "Symbol is not global",
};

#define likely(expr)   __builtin_expect (expr, 1)
#define unlikely(expr) __builtin_expect (expr, 0)

pthread_mutex_t dl_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;

static void set_dlerror(int err)
{
    format_buffer(dl_err_buf, sizeof(dl_err_buf), "%s: %s", dl_errors[err],
             linker_get_error());
    dl_err_str = (const char *)&dl_err_buf[0];
};

void *dlopen(const char *filename, int flag)
{
    soinfo *ret;

    pthread_mutex_lock(&dl_lock);
    ret = find_loaded_library(filename);

    if (!ret) {
      ret = load_library(filename, 1);
      if (ret) {
        soinfo_link_image(ret);
        soinfo_call_constructors(ret);
      }
    } else {
      ret->refcount++;
    }

    if (ret == NULL) {
        set_dlerror(DL_ERR_CANNOT_LOAD_LIBRARY);
    }
    pthread_mutex_unlock(&dl_lock);
    return ret;
}

const char *dlerror(void)
{
    const char *tmp = dl_err_str;
    dl_err_str = NULL;
    return (const char *)tmp;
}

void *dlsym(void *handle, const char *symbol)
{
    soinfo *found;
    Elf32_Sym *sym;
    unsigned bind;

    pthread_mutex_lock(&dl_lock);

    if(unlikely(handle == 0)) {
        set_dlerror(DL_ERR_INVALID_LIBRARY_HANDLE);
        goto err;
    }
    if(unlikely(symbol == 0)) {
        set_dlerror(DL_ERR_BAD_SYMBOL_NAME);
        goto err;
    }

    if(handle == RTLD_DEFAULT) {
        sym = lookup(symbol, &found, NULL);
    } else if(handle == RTLD_NEXT) {
        void *ret_addr = __builtin_return_address(0);
        soinfo *si = find_containing_library(ret_addr);

        sym = NULL;
        if(si && si->next) {
            sym = lookup(symbol, &found, si->next);
        }
    } else {
        found = (soinfo*)handle;
        sym = soinfo_lookup(found, symbol);
    }

    if(likely(sym != 0)) {
        bind = ELF32_ST_BIND(sym->st_info);

        // NACL MOD BEGIN UPSTREAM
        // Allow weak symbols as return values of dlsym. Without this,
        // dlsym("isalpha") may fail if 1. you are building your program
        // with g++ (not gcc), 2. you have -DNDEBUG, and 3. your
        // program calls isalpha directly. This issue happens even on
        // a real android device.
        if(likely((bind == STB_GLOBAL || bind == STB_WEAK) &&
                  (sym->st_shndx != 0))) {
        // NACL MOD END UPSTREAM
            // NACL MOD BEGIN
            // Use found->load_bias instead of found->base. Without
            // this, the calculation will be wrong for the main
            // executable. Upstream bionic already has this fix.
            unsigned ret = sym->st_value + found->load_bias;
            // NACL MOD END
            pthread_mutex_unlock(&dl_lock);
            return (void*)ret;
        }

        set_dlerror(DL_ERR_SYMBOL_NOT_GLOBAL);
    }
    else
        set_dlerror(DL_ERR_SYMBOL_NOT_FOUND);

err:
    pthread_mutex_unlock(&dl_lock);
    return 0;
}

int dladdr(const void *addr, Dl_info *info)
{
    int ret = 0;

    pthread_mutex_lock(&dl_lock);

    /* Determine if this address can be found in any library currently mapped */
    soinfo *si = find_containing_library(addr);

    if(si) {
        memset(info, 0, sizeof(Dl_info));

        info->dli_fname = si->name;
        info->dli_fbase = (void*)si->base;

        /* Determine if any symbol in the library contains the specified address */
        Elf32_Sym *sym = soinfo_find_symbol(si, addr);

        if(sym != NULL) {
            info->dli_sname = si->strtab + sym->st_name;
            info->dli_saddr = (void*)(si->base + sym->st_value);
        }

        ret = 1;
    }

    pthread_mutex_unlock(&dl_lock);

    return ret;
}

int dlclose(void* handle) {
    pthread_mutex_lock(&dl_lock);
    int result = soinfo_unload((soinfo*)handle);
    pthread_mutex_unlock(&dl_lock);
    return result;
}

_irt_syscalls_t** dl_irt_ptr() {
	return &g_nacl_irt_syscalls_ptr;
}

// NACL MOD BEGIN
// Added dl_iterate_phdr for arm.
#if defined(ANDROID_ARM_LINKER)
//                     0000000 00011111 111112 22222222 2333333 333344444444445555555 5556666666666777 77777778888
//                     0123456 78901234 567890 12345678 9012345 678901234567890123456 7890123456789012 34567890123
#define ANDROID_LIBDL_STRTAB \
                      "dlopen\0dlclose\0dlsym\0dlerror\0dladdr\0dl_unwind_find_exidx\0dl_iterate_phdr\0dl_irt_ptr\0"

// Add x86-64 support.
#elif defined(ANDROID_X86_LINKER) || defined(ANDROID_MIPS_LINKER) \
    || defined(ANDROID_X86_64_LINKER)
//                     0000000 00011111 111112 22222222 2333333 3333444444444455 55555555666
//                     0123456 78901234 567890 12345678 9012345 6789012345678901 23456789012
#define ANDROID_LIBDL_STRTAB \
                      "dlopen\0dlclose\0dlsym\0dlerror\0dladdr\0dl_iterate_phdr\0dl_irt_ptr\0"
#else
#error Unsupported architecture. Only ARM, MIPS, and x86 are presently supported.
#endif
// NACL MOD END


// NACL MOD BEGIN
// 64bit NaCl uses ELF64 but its pointer type is 32bit. This means we
// cannot initialize a 64bit integer in Elf64_Sym (st_value) by a
// pointer. Specifically, on x86-64b NaCl, we cannot compile code like
//
// Elf64_Sym sym = { st_value: (Elf64_Addr)&sym };
//
// So, we define another struct Elf64_Sym_NaCl. This is very similar
// to Elf64_Sym, but its st_value is divided into two 32bit integers
// (i.e., st_value and st_value_padding). This is only used to define
// |libdl_symtab| below. |libdl_symtab| will be passed to
// libdl_info.symtab in this file. Other code will not use this and
// use normal Elf64_Sym instead.
#if defined(ANDROID_X86_64_LINKER) && defined(__native_client__)
typedef struct {
  Elf64_Word st_name;
  unsigned char st_info;
  unsigned char st_other;
  Elf64_Half st_shndx;
  // Put lower bits first because we are little endian.
  unsigned st_value;
  // We will not fill this field, so this will be initialized to zero.
  unsigned st_value_padding;
  Elf64_Xword st_size;
} Elf64_Sym_NaCl;

// Static assertions for the layout of Elf64_Sym_NaCl.
#define STATIC_ASSERT(cond, name) \
  struct StaticAssert_ ## name { char name[(cond) ? 1 : -1]; }
STATIC_ASSERT(sizeof(Elf64_Sym_NaCl) == sizeof(Elf64_Sym),
              SizeOf_Elf64_Sym_NaCl);
STATIC_ASSERT(offsetof(Elf64_Sym_NaCl, st_value) ==
              offsetof(Elf64_Sym, st_value),
              OffsetOf_st_value);
STATIC_ASSERT(offsetof(Elf64_Sym_NaCl, st_size) ==
              offsetof(Elf64_Sym, st_size),
              OffsetOf_st_size);

// Remove map from Elf32_Addr to Elf64_Addr defined in linker.h.
#undef Elf32_Addr

static Elf64_Sym_NaCl libdl_symtab[] =
#else
static Elf32_Sym libdl_symtab[] =
#endif
{
// NACL MOD END
      // total length of libdl_info.strtab, including trailing 0
      // This is actually the the STH_UNDEF entry. Technically, it's
      // supposed to have st_name == 0, but instead, it points to an index
      // in the strtab with a \0 to make iterating through the symtab easier.
    { st_name: sizeof(ANDROID_LIBDL_STRTAB) - 1,
    },
    { st_name: 0,   // starting index of the name in libdl_info.strtab
      st_value: (Elf32_Addr) &dlopen,
      st_info: STB_GLOBAL << 4,
      st_shndx: 1,
    },
    { st_name: 7,
      st_value: (Elf32_Addr) &dlclose,
      st_info: STB_GLOBAL << 4,
      st_shndx: 1,
    },
    { st_name: 15,
      st_value: (Elf32_Addr) &dlsym,
      st_info: STB_GLOBAL << 4,
      st_shndx: 1,
    },
    { st_name: 21,
      st_value: (Elf32_Addr) &dlerror,
      st_info: STB_GLOBAL << 4,
      st_shndx: 1,
    },
    { st_name: 29,
      st_value: (Elf32_Addr) &dladdr,
      st_info: STB_GLOBAL << 4,
      st_shndx: 1,
    },
#ifdef ANDROID_ARM_LINKER
    { st_name: 36,
      st_value: (Elf32_Addr) &dl_unwind_find_exidx,
      st_info: STB_GLOBAL << 4,
      st_shndx: 1,
    },
    // NACL MOD BEGIN
    // Added dl_iterate_phdr for arm.
    { st_name: 57,
      st_value: (Elf32_Addr) &dl_iterate_phdr,
      st_info: STB_GLOBAL << 4,
      st_shndx: 1,
    },
    { st_name: 73,
      st_value: (Elf32_Addr) &dl_irt_ptr,
      st_info: STB_GLOBAL << 4,
      st_shndx: 1,
    },
    // Add x86-64 support.
#elif defined(ANDROID_X86_LINKER) || defined(ANDROID_MIPS_LINKER) \
    || defined(ANDROID_X86_64_LINKER)
    // NACL MOD END
    { st_name: 36,
      st_value: (Elf32_Addr) &dl_iterate_phdr,
      st_info: STB_GLOBAL << 4,
      st_shndx: 1,
    },
    { st_name: 52,
      st_value: (Elf32_Addr) &dl_irt_ptr,
      st_info: STB_GLOBAL << 4,
      st_shndx: 1,
    },
#endif
};

/* Fake out a hash table with a single bucket.
 * A search of the hash table will look through
 * libdl_symtab starting with index [1], then
 * use libdl_chains to find the next index to
 * look at.  libdl_chains should be set up to
 * walk through every element in libdl_symtab,
 * and then end with 0 (sentinel value).
 *
 * I.e., libdl_chains should look like
 * { 0, 2, 3, ... N, 0 } where N is the number
 * of actual symbols, or nelems(libdl_symtab)-1
 * (since the first element of libdl_symtab is not
 * a real symbol).
 *
 * (see _elf_lookup())
 *
 * Note that adding any new symbols here requires
 * stubbing them out in libdl.
 */
static unsigned libdl_buckets[1] = { 1 };
// NACL MOD BEGIN
// Size now varies because dl_iterate_phdr has been added for arm.
#ifdef ANDROID_ARM_LINKER
static unsigned libdl_chains[9] = { 0, 2, 3, 4, 5, 6, 7, 8, 0 };
#else
static unsigned libdl_chains[8] = { 0, 2, 3, 4, 5, 6, 7, 0 };
#endif
// NACL MOD END

soinfo libdl_info = {
    name: "libdl.so",
    flags: FLAG_LINKED,

    strtab: ANDROID_LIBDL_STRTAB,
    // NACL MOD BEGIN
    // Add a cast to convert Elf64_Sym_NaCl* to Elf32_Sym* (note that
    // Elf32_Sym is mapped to Elf64_Sym on x86-64).
    symtab: (Elf32_Sym *)libdl_symtab,
    // NACL MOD END

    nbucket: 1,
// NACL MOD BEGIN
// Allow size to vary because dl_iterate_phdr has been added for arm.
    nchain: sizeof(libdl_chains) / sizeof(*libdl_chains) - 1,
// NACL MOD END
    bucket: libdl_buckets,
    chain: libdl_chains,
};
